Simpler, one pointer: track two sets of ones, current set and previous set, resetting previous to 0 if 2 consecutive 0s are encountered. Add 1 if at least one 0 is encountered:

class Solution {

public int findMaxConsecutiveOnes(int[] nums) {
    int max = 0;
    int curr = 0, prev = 0, seenZero = 0;
    
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] == 0) {
            seenZero = 1;
            prev = curr;
            curr = 0;
        } else {
            curr++;
        }
        
        max = Math.max(max, curr + prev + seenZero);
    }
    
    return max;
}

}

Follow up infinite stream - Maintain the 'left', 'right' and 'last seen zero'. As soon as one encounters another 0 in stream, record the maxLength; make leftIndex = zeroIndex + 1, and set zeroIndex = right = curIndex. Again continue processing the stream.

does sliding window concept work with infinite stream of input nums as well? What is the reasoning if yes/no

Very simple solution is to track if you have seen a zero, the count of the current run of ones, the count of the last run of ones, and the max length run you've seen.

When you see a one, increment the current run count.
When you see a zero, note that you've seen one (if you don't see one, the max consecutive ones is length of the input array), then update max total seen to be max of current max total seen and the sum of the previous run, current run, plus one to "flip" the zero between them. Then set the previous run counter to the current run counter, and reset the current run counter back to 0.

When you reach the end, if you haven't seen a zero, you can return the maximum consecutive ones to be the input length, else, it's the max of max total run seen, and the sum of previous, current, plus one, same as in the iteration.

def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        seenZero = False
        currOnes = 0
        prevOnes = 0
        
        maxRun = 0
        
        for num in nums:
            if num == 1:
                currOnes += 1
            else:
                seenZero = True
                maxRun = max(maxRun, prevOnes + 1 + currOnes)
                prevOnes = currOnes
                currOnes = 0
                
        return len(nums) if not seenZero else max(maxRun, prevOnes + 1 + currOnes)

Why my solution below is still consuming 2ms whenever I run this piece of code, I feel like code below is exactly same as the approach here:

public int findMaxConsecutiveOnes(int[] nums) {

    int slow = 0;
    int fast = 0;
    
    int max = 0;                                 // [1,0,1,1,0]
    
    int index = 0;
    
    boolean isFlipped = false;
    
    while(fast < nums.length){
        if(nums[fast]==1){
            fast++;
        }else if(!isFlipped){
            index = fast;
            fast++;
            isFlipped = true;
        }else{
            isFlipped = false;
            slow = index+1;
            fast = slow;
        }
        
        max = Math.max(max,fast-slow);
    }
    
    return max;

}

Very simple solution with 1 pointer.

int findMaxConsecutiveOnes(vector& nums) {

    bool skipOne = true;
    int skipIdx = 0;
    int maxLen = 0;
    int serieLen = 0;
    
    for (int i = 0; i < nums.size(); i++) {
        
        if (nums[i] == 1 || skipOne) {
            serieLen++;
            if (nums[i] == 0) {
                skipOne = false;
                skipIdx = i;
            }
            
        } else {
            
            //num == 0 and a 0 was already skipped.
            // flush the counter and readjust the current serieLen
            
            maxLen = max(maxLen, serieLen);
            
            serieLen = i - skipIdx;
            skipIdx = i;
            
        }
        
    }
    
    maxLen = max(maxLen, serieLen);
        
    return maxLen;

Different version using sliding window :

class Solution:
def findMaxConsecutiveOnes(self, nums ) :

    if not nums:
        return

    start = 0
    res = float('-inf')
    d = {}

    for end in range(len(nums)):

        if nums[end] == 1 :
            pass
        else :
            if 0 not in d :
                d[0] = end
            else :
                start = d.get(0) + 1
                d[0] = end

        res = max(res, end - start + 1)
    return res

Little more optimized solution with two pointers than approach 2. This solution will have better runtime when numbers of zeros are less as compared to ones and are distributed. This solution is written in Java Language.
Runtime = O(n) and Space = O(1)

public int findMaxConsecutiveOnes(int[] nums) {
        int ans = 0; // it will hold the max length of valid sequence
        int start = 0; // it will hold the start index of valid sequence
        int zeroAt = -1; // store the last '0' encountered position, -1 means not encountered
        
        // iterate over numbers and noting indexes of '0' and 
        // start index of valid sequences
        for (int i = 0; i < nums.length; i++) {
            
            if (nums[i] == 0) {
                if (zeroAt > -1) { 
                    //if we have encountered a '0' already
                    // try to update the result and start position
                    ans = Math.max(ans, i - start);
                    start = zeroAt+1;
                }
                zeroAt = i; // always update new '0' position
            }
        }
        
        // finally check with last valid sequence, i.e., if nums[length-1] == 1
        ans = Math.max(ans, nums.length - start);
        
        return ans;
    }

Approach №2: on the second slide of algorithm visualization longestSequence should be equal to 2, not to 1, as we can swap first zero and get 2 consecutive 1s. We just need to start with longestSequence equals to 1 on the first slide.

Approach 1: Brute Force, when I run this approach in python3 for large lists I get 'time limit exceeded' error, but the same doesn't happen for the java solution. I am wondering if anyone has any insight as to why this is happening?